/**
 * 
 */
package de.mbenning.fsim.simulation.components;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

import org.springframework.beans.factory.annotation.Autowired;

import de.mbenning.fsim.domain.Position;
import de.mbenning.fsim.domain.Spieler;
import de.mbenning.fsim.domain.SystemPosition;
import de.mbenning.fsim.domain.Verein;
import de.mbenning.fsim.persistence.dao.interfaces.ISpielerDAO;
import de.mbenning.fsim.simulation.components.enums.HeimGastType;
import de.mbenning.fsim.simulation.components.enums.SystemType;

/**
 * @author Martin.Benning
 *
 */
public class Aufstellung {
	
	private Verein verein;
	private SystemType systemType;
	private List<Spieler> spieler = new ArrayList<Spieler>();
	private HeimGastType heimGast;
	private Spieler currentSpieler = null;
	
	private int torwart = 0;
	private int abwehr = 0;
	private int mittelfeld = 0;
	private int angriff = 0;
	
	private int tore = 0;
	private int count = 0;
	
	@Autowired
	private ISpielerDAO spielerDAO;	
	
	public Aufstellung(Verein verein, SystemType systemType, HeimGastType heimGastType) {
		this.verein = verein;
		this.systemType = systemType;
		this.heimGast = heimGastType;
	}
	
	public void doAutoAufstellung() {
		Spieler temp = null;
		String[] taktik = systemType.getName().split("-");
		
		List<Spieler> tor = spielerDAO.findSpielerByPositionAndLevel(this.verein, Position.TOR);
		List<Spieler> abw = spielerDAO.findSpielerByPositionAndLevel(this.verein, Position.ABW);
		List<Spieler> mit = spielerDAO.findSpielerByPositionAndLevel(this.verein, Position.MIT);
		List<Spieler> ang = spielerDAO.findSpielerByPositionAndLevel(this.verein, Position.ANG);
		
		spieler.add(tor.get(0));
		torwart = tor.get(0).getLevel();
		
		List<Spieler> rvs = spielerDAO.findSpielerBySystemPositionAndLevel(this.verein, SystemPosition.RV);
		if(rvs.size() >= 1) {
			spieler.add(rvs.get(0));
			abwehr = abwehr + rvs.get(0).getLevel();
		} else {
			temp = abw.remove(0);
			spieler.add(temp);
			abwehr = abwehr + temp.getLevel();
		}
		
		
		List<Spieler> lvs = spielerDAO.findSpielerBySystemPositionAndLevel(this.verein, SystemPosition.LV);
		if(lvs.size() >= 1) {
			spieler.add(lvs.get(0));
			abwehr = abwehr + lvs.get(0).getLevel();
		} else {
			temp = abw.remove(0);
			spieler.add(temp);
			abwehr = abwehr + temp.getLevel();
		}
		
		List<Spieler> ivs = spielerDAO.findSpielerBySystemPositionAndLevel(this.verein, SystemPosition.IV);
		if(ivs.size() >= 2) {
			spieler.add(ivs.get(0));
			abwehr = abwehr + ivs.get(0).getLevel();
			spieler.add(ivs.get(1));
			abwehr = abwehr + ivs.get(1).getLevel();
		} else {
			temp = abw.remove(0);
			spieler.add(temp);
			abwehr = abwehr + temp.getLevel();
			temp = abw.remove(0);
			spieler.add(temp);
			abwehr = abwehr + temp.getLevel();
		}
		
		List<Spieler> rms = spielerDAO.findSpielerBySystemPositionAndLevel(this.verein, SystemPosition.RM);
		if(rms.size() >= 1) {
			spieler.add(rms.get(0));
			mittelfeld = mittelfeld + rms.get(0).getLevel();
		} else {
			temp = mit.remove(0);
			spieler.add(temp);
			mittelfeld = mittelfeld + temp.getLevel();
		}
		
		List<Spieler> zms = spielerDAO.findSpielerBySystemPositionAndLevel(this.verein, SystemPosition.ZM);
		if(zms.size() >= 1) {
			spieler.add(zms.get(0));
			mittelfeld = mittelfeld + zms.get(0).getLevel();
		} else {
			temp = mit.remove(0);
			spieler.add(temp);
			mittelfeld = mittelfeld + temp.getLevel();
		}
		
		List<Spieler> lms = spielerDAO.findSpielerBySystemPositionAndLevel(this.verein, SystemPosition.LM);
		if(lms.size() >= 1) {
			spieler.add(lms.get(0));
			mittelfeld = mittelfeld + lms.get(0).getLevel();
		} else {
			temp = mit.remove(0);
			spieler.add(temp);
			mittelfeld = mittelfeld + temp.getLevel();
		}
		
		List<Spieler> ms = spielerDAO.findSpielerBySystemPositionAndLevel(this.verein, SystemPosition.MS);
		if(ms.size() >= 1) {
			spieler.add(ms.get(0));
			angriff = angriff + ms.get(0).getLevel();
		} else {
			temp = ang.remove(0);
			spieler.add(temp);
			angriff = angriff + temp.getLevel();
		}
		
		List<Spieler> la = spielerDAO.findSpielerBySystemPositionAndLevel(this.verein, SystemPosition.LA);
		if(la.size() >= 1) {
			spieler.add(la.get(0));
			angriff = angriff + la.get(0).getLevel();
		} else {
			temp = ang.remove(0);
			spieler.add(temp);
			angriff = angriff + temp.getLevel();
		}
		
		for (Spieler spieler : this.spieler) {
			System.out.println(spieler.getName() + " " + spieler.getLevel());
			
		}
		
		System.out.println("TOR: " + torwart + " ABW: " + abwehr + " MIT: " + mittelfeld + " ANG: " + angriff);
		
//		for(int i = 1; i < Integer.parseInt(taktik[0]); i++) {
//			
//		}
	}
	
	public Spieler randomizeSpieler() {
		int index = 0;
		do {
			index = new Random().nextInt(this.spieler.size());
		} while(index <= 0);
		this.currentSpieler = this.spieler.get((index));
		return currentSpieler;
	}

	public Verein getVerein() {
		return verein;
	}

	public void setVerein(Verein verein) {
		this.verein = verein;
	}

	public SystemType getSystemType() {
		return systemType;
	}

	public void setSystemType(SystemType systemType) {
		this.systemType = systemType;
	}

	public List<Spieler> getSpieler() {
		return spieler;
	}

	public void setSpieler(List<Spieler> spieler) {
		this.spieler = spieler;
	}

	public HeimGastType getHeimGast() {
		return heimGast;
	}

	public void setHeimGast(HeimGastType heimGast) {
		this.heimGast = heimGast;
	}

	public ISpielerDAO getSpielerDAO() {
		return spielerDAO;
	}

	public void setSpielerDAO(ISpielerDAO spielerDAO) {
		this.spielerDAO = spielerDAO;
	}

	public int getTorwart() {
		return torwart;
	}

	public int getAbwehr() {
		return abwehr;
	}

	public int getMittelfeld() {
		return mittelfeld;
	}

	public int getAngriff() {
		return angriff;
	}
	
	public void incCount() {
		this.count++;
	}
	
	public void incTore() {
		this.tore++;
	}
	
	public int getTore() {
		return tore;
	}
	
	public int getCount() {
		return this.count;
	}
	
	public Spieler getCurrentSpieler() {
		return currentSpieler;
	}
}
